a+ file open mode
B
binary digits
bit
byte
C
character set
characters
D
data hierarchy
database
database management system (DBMS)
E
end-of-file indicator
F
feof
fgetc
field
file
file open mode
file pointer
file position pointer
FILE structures
fputc
fread
fseek
fwrite
O
open a file
R
r+ open file mode
randomly accessed file
record
record key
S
SEEK_END
SEEK_SET
sequential access file
sizeof operator
standard error
standard input
standard output
W
w+ file open mode
Samuel Goldwyn
The flag is passing by.
Henry Holcomb Bennett
William James
Senator Frank Church
Senate Intelligence
Subcommittee Hearing,
1975
Fig. 23.2 - C's view of a file of n bytes.
Fig. 23.3 - Creating a sequential file.
Fig. 23.4 - End-of-file key combinations for various popular computer systems.
Fig. 23.5 - The relationship between FILE pointers, FILE structures and FCBs.
Fig. 23.6 - File open modes.
Fig. 23.7 - Reading and printing a sequential file.
Fig. 23.8 - Credit inquiry program.
Fig. 23.10 - View of a randomly accessed file with fixed-length records.
Fig. 23.11 - Creating a random access file sequentially.
Fig. 23.12 - Writing data randomly to a randomly accessed file.
Fig. 23.14 - The file position pointer indicating an offset of 5 bytes from the beginning of the file.
Fig. 23.15 - Reading a random access file sequentially.
Fig. 23.16 - Bank account program.
a) 1s, 0s. b) Bit. c) File. d) Characters. e) Database. f) fclose. g) fscanf.
h) getc or fgetc. i) fgets. j) fopen. k) fread. l) fseek.
a)
b)
c)
d)
e)
g)
h)
i)
a)
b)
c)
d)
e)
f)
a)
file pointer.
b)
c)
e)
/* Exercise 23.5 Solution *//* NOTE: This program was run using the */
/* data in Exercise 23.8 */
#include <stdio.h>
#include <stdlib.h>
main()
{
int masterAccount, transactionAccount;
float masterBalance, transactionBalance;
char masterName[23];
FILE *ofPtr, *tfPtr, *nfPtr;
if ((ofPtr = fopen("oldmast.dat", "r")) == NULL) {
printf("Unable to open oldmast.dat\n");
exit(1);
}
if ((tfPtr = fopen("trans.dat", "r")) == NULL) {
printf("Unable to open trans.dat\n");
exit(1);
}
if ((nfPtr = fopen("newmast.dat", "w")) == NULL) {
printf("Unable to open newmast.dat\n");
exit(1);
}
printf("Processing....\n");
fscanf(tfPtr, "%d%f", &transactionAccount, &transactionBalance);
while (!feof(tfPtr)) {
fscanf(ofPtr, "%d%s%f", &masterAccount, masterName, &masterBalance);
while (masterAccount < transactionAccount &&
!feof(ofPtr)) {
fprintf(nfPtr, "%d %s %.2f\n", masterAccount, masterName,
masterBalance);
printf("%d %s %.2f\n", masterAccount, masterName, masterBalance);
fscanf(ofPtr, "%d%s%f", &masterAccount, masterName,
&masterBalance);
}
if (masterAccount == transactionAccount) {
masterBalance += transactionBalance;
fprintf(nfPtr, "%d %s %.2f\n", masterAccount, masterName,
masterBalance);
printf("%d %s %.2f\n", masterAccount, masterName, masterBalance);
}
else if (masterAccount > transactionAccount) {
printf("Unmatched transaction record for account %d\n",
transactionAccount);
fprintf(nfPtr, "%d %s %.2f\n", masterAccount,
masterName,
masterBalance);
printf("%d %s %.2f\n", masterAccount, masterName, masterBalance);
}
else
printf("Unmatched transaction record for account %d\n",
transactionAccount);
fscanf(tfPtr, "%d%f", &transactionAccount, &transactionBalance);
}
while (!feof(ofPtr)) {
fscanf(ofPtr, "%d%s%f", &masterAccount, masterName, &masterBalance);
fprintf(nfPtr, "%d %s %.2f", masterAccount, masterName,
masterBalance); printf("%d %s %.2f", masterAccount, masterName, masterBalance);
}
fclose(ofPtr);
fclose(tfPtr);
fclose(nfPtr);
return 0;
}
Processing....
100 Jones 375.31
300 Smith 89.30
Unmatched transaction record for account 400
500 Sharp 0.00
700 Green -14.22
Unmatched transaction record for account 900
/* Exercise 23.6 Solution */#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <stdlib.h>
void initializeFile(FILE *);
void inputData(FILE *);
int instructions(void);
void listTools(FILE *);
void updateRecord(FILE *);
void insertRecord(FILE *);
void deleteRecord(FILE *);
struct hardwareData {
int partNumber;
char toolName[30];
int inStock;
float unitPrice;
};
main()
{
FILE *filePtr;
char response[2];
int process;
printf("Should the file be initialized (Y or N): ");
scanf("%s", response);
while (toupper(response[0]) != 'Y' && toupper(response[0]) != 'N') {
printf("Invalid response. Enter Y or N: ");
scanf("%s", response);
}
if (toupper(response[0]) == 'Y') {
if ((filePtr = fopen("hardware.dat", "w")) == NULL) {
printf("File could not be opened.\n");
exit(1);
}
initializeFile(filePtr);
inputData(filePtr);
fclose(filePtr);
}
if ((filePtr = fopen("hardware.dat", "r+")) == NULL) {
printf("File could not be opened.\n");
exit(1);
}while ((process = instructions()) != 5) {
switch (process) {
case 1:
listTools(filePtr);
break;
case 2:
updateRecord(filePtr);
break;
case 3:
insertRecord(filePtr);
break;
case 4:
deleteRecord(filePtr);
break;
}
}
fclose(filePtr);
return 0;
}
void initializeFile(FILE *fPtr)
{
struct hardwareData blankItem = {0, "", 0, 0.0};
int i;
for (i = 0; i <= 99; i++)
fwrite(&blankItem, sizeof(struct hardwareData), 1, fPtr);
}
void inputData(FILE *fPtr)
{
struct hardwareData temp;
char c;
printf("Enter the partnumber (0 - 99, -1 to end input): ");
scanf("%d", &temp.partNumber);
while (temp.partNumber != -1) {
printf("Enter the tool name, quantity, and price:\n");
scanf(" %[^0-9] %d%f", temp.toolName, &temp.inStock,
&temp.unitPrice); fseek(fPtr, temp.partNumber * sizeof(struct hardwareData),
SEEK_SET);
fwrite(&temp, sizeof(struct hardwareData), 1, fPtr);
printf("Enter the partnumber (0 - 99, -1 to end input): ");
scanf("%d", &temp.partNumber);
}
}
int instructions(void)
{
int choice;
printf("\n%s\n%s\n%s\n%s\n%s\n%s\n? ", "Enter a choice:",
"1 List all tools.", "2 Update record.", "3 Insert
record.",
"4 Delete record.", "5 End program.");
scanf("%d", &choice);
while (choice < 1 || choice > 5) {
printf("Invalid choice. Enter again: ");
scanf("%d", &choice);
}
return choice;
}
void listTools(FILE *fPtr)
{
struct hardwareData temp;
fseek(fPtr, sizeof(struct hardwareData), SEEK_SET);
printf("%8s %-29s%10s%8s\n", "Record #", "Tool name", "Quantity",
"Cost");
while (!feof(fPtr)) {
fread(&temp, sizeof(struct hardwareData), 1, fPtr);
if (temp.partNumber)
printf("%-8d %-29s%10d%8.2f\n", temp.partNumber,
temp.toolName, temp.inStock, temp.unitPrice);
}}
void updateRecord(FILE *fPtr)
{
struct hardwareData temp;
int part;
printf("Enter the partnumber for update: ");
scanf("%d", &part);
fseek(fPtr, part * sizeof(struct hardwareData), SEEK_SET);fread(&temp, sizeof(struct hardwareData), 1, fPtr);
if (temp.partNumber) {
printf("%8s %-29s%10s%8s\n", "Record #", "Tool name", "Quantity","Cost");
printf("%-8d %-29s%10d%8.2f\n", temp.partNumber, temp.toolName,
temp.inStock, temp.unitPrice);
printf("Enter the tool name, quantity, and price:\n");
scanf(" %[^0-9] %d%f", temp.toolName, &temp.inStock,
Price);
fseek(fPtr, temp.partNumber * sizeof(struct
hardwareData),
SEEK_SET);
fwrite(&temp, sizeof(struct hardwareData), 1, fPtr);
}
else
printf("Cannot update. The record is empty.\n");
}
void insertRecord(FILE *fPtr)
{
struct hardwareData temp;
int part;printf("Enter the partnumber for insertion: ");
scanf("%d", &part);
fseek(fPtr, part * sizeof(struct hardwareData), SEEK_SET);
fread(&temp, sizeof(struct hardwareData), 1, fPtr);
if (!temp.partNumber) {
temp.partNumber = part;
printf("Enter the tool name, quantity, and price:\n");
scanf(" %[^0-9] %d%f", temp.toolName, &temp.inStock,
Price);
fseek(fPtr, temp.partNumber * sizeof(struct
hardwareData),
SEEK_SET);
fwrite(&temp, sizeof(struct hardwareData), 1, fPtr);
}
else
printf("Cannot insert. The record contains information.\n");
}
void deleteRecord(FILE *fPtr)
{
struct hardwareData blankItem = {0, "", 0, 0.0}, temp;
int part;
printf("Enter the partnumber for deletion: ");
scanf("%d", &part);
fseek(fPtr, part * sizeof(struct hardwareData), SEEK_SET);
fread(&temp, sizeof(struct hardwareData), 1, fPtr);
if (temp.partNumber) {
fseek(fPtr, part * sizeof(struct hardwareData), SEEK_SET);
fwrite(&blankItem, sizeof(struct hardwareData), 1, fPtr);
printf("Record deleted.\n");
}else
printf("Cannot delete. The record is empty.\n");
}
/* Exercise 23.7 Solution */#include <stdio.h>
main()
{
FILE *outPtr;
outPtr = fopen("datasize.dat", "w");
fprintf(outPtr, "%s%16s\n", "Data type", "Size");
fprintf(outPtr, "%s%21d\n", "char", sizeof(char));
fprintf(outPtr, "%s%12d\n", "unsigned char", sizeof(unsigned char));
fprintf(outPtr, "%s%16d\n", "short int", sizeof(short int));fprintf(outPtr, "%s%7d\n", "unsigned short int",
sizeof(unsigned short int)); fprintf(outPtr, "%s%22d\n", "int", sizeof(int));
fprintf(outPtr, "%s%13d\n", "unsigned int", sizeof(unsigned int));
fprintf(outPtr, "%s%17d\n", "long int", sizeof(long int));
fprintf(outPtr, "%s%8d\n", "unsigned long int",
sizeof(unsigned long int));
fprintf(outPtr, "%s%20d\n", "float", sizeof(float));
fprintf(outPtr, "%s%19d\n", "double", sizeof(double));fprintf(outPtr, "%s%14d\n", "long double", sizeof(long double));
fclose(outPtr);
return 0;
}
Data type Size
char 1
unsigned char 1
short int 2
unsigned short int 2
int 2
unsigned int 2
long int 4
unsigned long int 4
float 4
double 10
long double 10
a)
b)
c)
d)
e)
f)
g)
h)
j)
k)
l)
a)
b)
c)
d)
e)
g)
h)
i)
Write a single statement to accomplish each of the following. Assume that each of these statements applies to the same program.
a)
b)
c)
d)
f)
a)
b)
c)
e)if ((tfPtr = fopen("tools.dat", "w")) != NULL)
Exercise 11.3 asked the reader to write a series of single statements. Actually, these statements form the core of an important type of file processing program, namely, a file-matching program. In commercial data processing, it is common to have several files in each system. In an accounts receivable system, for example, there is generally a master file containing detailed information about each customer such as the customer's name, address, telephone number, outstanding balance, credit limit, discount terms, contract arrangements, and possibly a condensed history of recent purchases and cash payments.
As transactions occur (i.e., sales are made and cash payments arrive in the mail), they are entered into a file. At the end of each business period (i.e., a month for
File-matching programs must deal with certain problems that do not exist in single-file programs. For example, a match does not always occur. A customer on the master file may not have made any purchases or cash payments in the current business period, and therefore no record for this customer will appear on the transaction file. Similarly, a customer who did make some purchases or cash
Use the statements written in Exercise 11.3 as a basis for writing a complete file- matching accounts receivable program. Use the account number on each file as the record key for matching purposes. Assume that each file is a sequential file with records stored in increasing account number order.
When a match occurs (i.e., records with the same account number appear on both the master file and the transaction file), add the dollar amount on the transaction file to the current balance on the master file, and write the "newmast.dat" record. (Assume that purchases are indicated by positive amounts on the transaction file, and that payments are indicated by negative amounts.) When there is a master record for a particular account but no
You are the owner of a hardware store and need to keep an inventory that can tell you what tools you have, how many you have, and the cost of each one. Write a program that initializes the file "hardware.dat" to 100 empty records, lets you input the data concerning each tool, enables you to list all your tools, lets you delete a record for a tool that you no longer have, and lets you update any information in the file. The tool identification number should be the record number. Use the following information to start your file:
Write a program that uses the sizeof operator to determine the sizes in bytes of the various data types on your computer system. Write the results to the file "datasize.dat" so you may print the results later. The format for the results in the file should be as shown on the next screen.
Note: The type sizes on your computer may not be the same as the ones listed in the table.
23.1
23.2
23.3
23.4
23.5
23.6
23.7
23.8
23.10
23.11
Terminology
Figures
Storage of data in variables and arrays is temporary; all such data is lost when a program terminates. Files are used for permanent retention of large amounts of data. Computers store files on secondary storage devices, especially disk storage devices. In this chapter, we explain how data files are created, updated, and processed by C programs. We consider both sequential access files and random access files.
Ultimately, all data items processed by a computer are reduced to combinations of zeros and ones. This occurs because it is simple and economical to build electronic devices that can assume two stable states--one of the states represents 0 and the other represents 1. It is remarkable that the impressive functions performed by computers involve only the most fundamental manipulations of 0s and 1s.
1. Social Security number
2. Name
3. Address
4. Hourly salary rate
5. Number of exemptions claimed
7. Amount of Federal taxes withheld, etc.
Thus, a record is a group of related fields. In the preceding example, each of the fields belongs to the same employee. Of course, a particular company may have many employees, and will have a payroll record for each employee. A file is a group of related records. A company's payroll file normally contains one record for each employee. Thus, a payroll file for a small company might contain only 22 records, whereas a payroll file for a large company might contain 100,000 records. It is not unusual for an organization to have hundreds or even thousands of files, with many
23.1 illustrates the
data hierarchy.C views each file simply as a sequential stream of bytes (
Fig. 23.2). Each file ends either with an end-of-file
marker or at a specific byte number recorded in a
system maintained, administrative data structure. When
a file is opened, a stream is associated with the file.
Three files and their associated streams are
automatically opened when program execution
begins--the standard input, the standard output, and
the standard error. Streams provide communication
channels between files and programs. For example, the
standard input stream enables a program to read data C imposes no structure on a file. Thus, notions like a record of a file do not exist as part of the C language. Therefore, the programmer must provide any file structure to meet the requirements of each particular application. In the following example, we see how the programmer may impose a record structure on a file.
Fig. 23.3 creates a simple sequential
access file that might be used in an accounts receivable
system to help keep track of the amounts owed by a
company's credit clients. For each client, the program
obtains an account number, the client's name, and the FILE *cfPtr;
have a separately declared pointer
of type FILE that is used to refer to the file. The line
if ((cfPtr = fopen("clients.dat", "w")) == NULL)
names the file--"clients.dat"--to be used by the
program and establishes a "line of communication"
with the file. The file pointer cfPtr is assigned a pointer
to the FILE structure for the file opened with fopen. 
structure is used to determine whether the file
pointer cfPtr is NULL (i.e., the file is not opened). If it
is NULL, an error message is printed and the program
ends. Otherwise, the input is processed and written to
the file. Figure 23.4 lists the key combinations for
entering end-of-file for various computer systems. while (!feof(stdin))uses function feof to determine whether the end-of-file indicator is set for the file to which stdin refers. The end-of-file indicator informs the program that there is no more data to be processed. In the program of Fig.
23.3, the end-of-file indicator is set for the standard
input when the user enters the end-of-file key
combination. The argument to function feof is a pointer
to the file being tested for the end-of-file indicator
(stdin in this case). The function returns a nonzero fprintf(cfPtr, "%d %s %.2f\n", account,writesname,balance);
data to the file clients.dat. The data may be
retrieved later by a program designed to read the file
(see Section 23.5). Function fprintf is 
equivalent to
printf except that fprintf also receives as an argument
a file pointer for the file to which the data will be
written. file pointer (rather than the file
name) as an argument. If function fclose is not called
explicitly, the operating system normally will close the
file when program execution terminates. This is an
example of 
operating system "housekeeping."Fig. 23.3, the
user enters information for five accounts, and then
enters end-of-file to signal that data entry is complete.
The sample execution does not show how the data
records actually appear in the file. To verify that the file
has been created successfully, in the next section we Figure 23.5 illustrates the relationship between FILE
pointers, FILE structures, and FCBs in memory. When
the file "clients.dat" is opened, an FCB for the file is
copied into memory. The figure shows the connection
between the file pointer returned by fopen and the FCB
used by the operating system to administer the file.create a file, or to discard the contents of a file
before writing data, open the file for writing ("w"). To
read an existing file, open it for reading ("r"). To add
records to the end of an existing file, open the file for
appending ("a"). To open a file so that it may be
written to and read from, open the file for updating in
one of the three update modes--"r+", "w+", or a+".
Mode "r+" opens a file for reading and writing. Mode
"w+" creates a file for reading and writing. If the file
already exists, the file is opened and the current
contents of the file are discarded. Mode "a+" opens a error occurs while opening a file in any mode,
fopen returns NULL.Data are stored in files so that the data may be retrieved for processing when needed. The previous section demonstrated how to create a file for sequential access. In this section, we discuss how to read data sequentially from a file.
Fig. 23.7 reads records from the file
"clients.dat" created by the program of Fig. 23.3, and
prints the contents of the records. The statementFILE *cfPtr;indicates that cfPtr is a pointer to a FILE. The line
if ((cfPtr = fopen("clients.dat", "r")) == NULL)
attempts to open the file "clients.dat" for reading
("r"), and determines whether the file is opened
successfully (i.e., fopen does not return NULL). The
statementfscanf(cfPtr, "%d%s%f", &account, name, &balance);reads a "record" from the file. Function fscanf is equivalent to function scanf except fscanf receives as an argument a file pointer for the file from which the data is read. After the preceding statement is executed the first time, account will have the value 100, name will have the value "Jones", and balance will have the
rewind(cfPtr);
Fig. 23.8) that allows a credit
manager to obtain lists of customers with zero balances
(i.e., customers who do not owe any money), customers
with credit balances (i.e., customers to whom the 300 White 0.00If the record is rewritten beginning at the same location in the file using the new name, the record would be
300 Worthington 0.00
The new record is larger than the original record. The
characters beyond the second "o" in "Worthington"
would overwrite the beginning of the next sequential
As we stated previously, records in a file created with the formatted output function fprintf are not necessarily the same length. However, individual records of a randomly accessed file are normally fixed in length and may be accessed directly (and thus quickly) without searching through other records. This makes randomly accessed files appropriate for airline reservation systems, banking systems, point-of-sale systems, and other kinds of transaction processing systems that require rapid access to specific data. There are other ways of implementing randomly accessed
23.10 illustrates one way to implement a
randomly accessed file. Such a file is like a freight train
with many cars--some empty and some with cargo.
Each car in the train is the same length.Function fwrite transfers a specified number of bytes beginning at a specified location in memory to a file. The data is written beginning at the location in the file indicated by the file position pointer. Function fread transfers a specified number of bytes from the location in the file specified by the file position pointer to an area in memory beginning with a specified address. Now, when writing an integer, instead of using
fprintf(fPtr, "%d", number);
fwrite(&number, sizeof(int), 1, fPtr);which always writes 4 bytes (or 2 bytes on a system with 2-byte integers) from variable number to the file represented by fPtr (we will explain the 1 argument shortly). Later, fread can be used to read 4 of those bytes into integer variable number. Although fread and fwrite read and write data such as integers in fixed- size rather than variable-size format, the data they handle is processed in computer "raw data" format (i.e.,
Fig. 23.11 shows how to open a randomly
accessed file, define a record format using a struct,
write data to the disk, and close the file. This program fwrite(&blankClient, sizeof(struct clientData),1, cfPtr);
parentheses (in this case struct
clientData). The sizeof operator is a compile-time
unary operator that returns an unsigned integer. The
sizeof operator can be used to determine the size in
bytes of any data type or expression. For example,
sizeof(int) is used to determine whether an integer is
stored in 2 or 4 bytes on a particular computer. The program of
Fig. 23.12 writes data to the file
"credit.dat". It uses the combination of fseek and
fwrite to store data at specific locations in the file.
Function fseek sets the file position pointer to a specific
position in the file, then fwrite writes the data. fseek(cfPtr, (accountNum - 1)positions the file position pointer for the file referenced by cfPtr to the byte location calculated by* sizeof(struct clientData), SEEK_SET);
Figure 23.14 int fseek(FILE *stream, long int offset, int whence);where offset is the number of bytes from location whence in the file pointed to by stream. The argument whence can have one of three values--SEEK_SET, SEEK_CUR or SEEK_END--indicating the location in the file from which the seek begins. SEEK_SET
Function fread reads a specified number of bytes from a file into memory. For example, the statement
fread(&client, sizeof(struct clientData), 1, cfPtr);reads the number of bytes determined by sizeof(struct clientData) from the file referenced by cfPtr and stores the data in the structure client. The bytes are read from the location in the file specified by the file position pointer. Function fread can be used to read several fixed-size array elements by providing a pointer to the
Fig. 23.15 reads sequentially every record
in the "credit.dat" file, determines whether each
record contains data, and prints the formatted data for
records containing data. The feof function determines
when the end of the file is reached, and the fread
function transfers data from the disk to the clientData
structure client. Processing Program
We now present a substantial transaction processing program using randomly accessed files. The program maintains a bank's account information. The program updates existing accounts, adds new accounts, deletes accounts, and stores a listing of all the current accounts in a text file for printing. We assume that the program of
Fig. 23.11 has been executed to create the file
credit.dat.Acct Last Name First Name BalanceOption 2 calls the function updateRecord to update an account. The function will only update a record that already exists, so the function first checks to see if the29 Brown Nancy -24.54
33 Dunn Stacey 314.33
37 Barker Doug 0.00
88 Smith Dave 258.34
96 Stone Sam 34.98
Enter account to update (1 - 100): 37
37 Barker Doug 0.00
Enter charge (+) or payment (-): +87.99
37 Barker Doug 87.99Option 3 calls the function newRecord to add a new account to the file. If the user enters an account number for an existing account, newRecord displays an error message that the record already contains information, and the menu choices are printed again. This function uses the same process to add a new account as does the program in
Fig. 23.12. A typical output for option 3 isEnter new account number (1 - 100): 22
Enter lastname, firstname, balance
? Johnston Sarah 247.45
ig. 23.16. Note that
the file "credit.dat" is opened for update (reading and
writing) using "r+" mode.